package com.cictec.middleware.core.entity;

import java.io.Serializable;
import java.util.Date;

import javax.persistence.Column;
import javax.persistence.Id;
import javax.persistence.Table;

import com.cictec.middleware.commons.utils.Constants;


@Table(name = "t_warn_msg")
public class WarnMsg implements Serializable {
	
	/**
	 * 报警是否被关闭
	 * @return
	 */
	public boolean isClosed(){
		
		if(getWarnClosedFlag() != null){
			return getWarnClosedFlag().equals(Constants.VAL_WARN_CLOSED_0);
		}
		
		return false;
		
	}
	
	/**
	 * 主键
	 */
	@Id
	@Column(name = "warn_uuid")
	private String warnUuid;

	/**
	 * 线路uuid
	 */
	@Column(name = "warn_line_uuid")
	private String warnLineUuid;

	/**
	 * 司机uuid
	 */
	@Column(name = "warn_drv_uuid")
	private String warnDrvUuid;

	/**
	 * 车辆uuid
	 */
	@Column(name = "warn_bus_uuid")
	private String warnBusUuid;

	/**
	 * 设备uuid
	 */
	@Column(name = "warn_dev_uuid")
	private String warnDevUuid;

	/**
	 * 报警开始时间
	 */
	@Column(name = "warn_start_time")
	private String warnStartTime;

	/**
	 * 报警结束时间
	 */
	@Column(name = "warn_end_time")
	private String warnEndTime;

	/**
	 * 报警类型 3：故障，4：事故，6：报警，7：偏线，8：超速，9停车，10回场 延安调度系统处理（超速、偏线、报警、停车、回场）5种报警
	 */
	@Column(name = "warn_type")
	private String warnType;

	/**
	 * 超速时的速度
	 */
	@Column(name = "warn_speed")
	private String warnSpeed;

	/**
	 * 报警里程(单位：米)
	 */
	@Column(name = "warn_miles")
	private String warnMiles;

	/**
	 * 报警时长（秒）
	 */
	@Column(name = "warn_duration")
	private String warnDuration;

	/**
	 * 报警起始位置经度
	 */
	@Column(name = "warn_start_lng")
	private String warnStartLng;

	/**
	 * 报警始起位置纬度
	 */
	@Column(name = "warn_start_lat")
	private String warnStartLat;

	/**
	 * 报警结束位置经度
	 */
	@Column(name = "warn_end_lng")
	private String warnEndLng;

	/**
	 * 报警结束位置纬度
	 */
	@Column(name = "warn_end_lat")
	private String warnEndLat;

	/**
	 * 入库时间
	 */
	@Column(name = "warn_storage_time")
	private String warnStorageTime;

	/**
	 * 更新时间
	 */
	@Column(name = "warn_update_time")
	private String warnUpdateTime;

	/**
	 * 删除标记 1：启用 0：禁用
	 */
	@Column(name = "warn_isvalid")
	private String warnIsvalid;

	/**
	 * 报警关闭标识（0-未关闭，1-被手动关闭）
	 */
	@Column(name = "warn_closed_flag")
	private String warnClosedFlag;

	/**
	 * 关闭报警调度员ID
	 */
	@Column(name = "warn_closed_by")
	private String warnClosedBy;

	/**
	 * 报警关闭时间
	 */
	@Column(name = "warn_closed_time")
	private Date warnClosedTime;

	/**
	 * 报警关闭说明
	 */
	@Column(name = "warn_closed_note")
	private String warnClosedNote;

	/**
	 * 运营状态判定，0：非运营，1：运营。该字段由调度员判定，确定报警期间的里程计入运营里程还是非运营里程。
	 */
	@Column(name = "warn_oper_status")
	private String warnOperStatus;

	/**
	 * 报警相关的其它业务表格UUID。根据报警的类型有关，偏线报警时，该字段指向t_bus_position_section
	 */
	@Column(name = "warn_ref_uuid")
	private String warnRefUuid;

	/**
	 * 报警开始时的里程表数据值
	 */
	@Column(name = "warn_start_odometer")
	private Double warnStartOdometer;

	/**
	 * 报警结束时的里程表数值
	 */
	@Column(name = "warn_end_odometer")
	private Double warnEndOdometer;

	/**
	 * 报警站点uuid-如果报警类型为甩站、压站时不为空
	 */
	@Column(name = "warn_sta_uuid")
	private String warnStaUuid;

	/**
	 * 警告信息是否已读（用于直线图显示）0:未读;1:已读
	 */
	@Column(name = "warn_is_read")
	private String warnIsRead;

	private static final long serialVersionUID = 1L;

	/**
	 * 获取主键
	 *
	 * @return warn_uuid - 主键
	 */
	public String getWarnUuid() {
		return warnUuid;
	}

	/**
	 * 设置主键
	 *
	 * @param warnUuid
	 *            主键
	 */
	public void setWarnUuid(String warnUuid) {
		this.warnUuid = warnUuid == null ? null : warnUuid.trim();
	}

	/**
	 * 获取线路uuid
	 *
	 * @return warn_line_uuid - 线路uuid
	 */
	public String getWarnLineUuid() {
		return warnLineUuid;
	}

	/**
	 * 设置线路uuid
	 *
	 * @param warnLineUuid
	 *            线路uuid
	 */
	public void setWarnLineUuid(String warnLineUuid) {
		this.warnLineUuid = warnLineUuid == null ? null : warnLineUuid.trim();
	}

	/**
	 * 获取司机uuid
	 *
	 * @return warn_drv_uuid - 司机uuid
	 */
	public String getWarnDrvUuid() {
		return warnDrvUuid;
	}

	/**
	 * 设置司机uuid
	 *
	 * @param warnDrvUuid
	 *            司机uuid
	 */
	public void setWarnDrvUuid(String warnDrvUuid) {
		this.warnDrvUuid = warnDrvUuid == null ? null : warnDrvUuid.trim();
	}

	/**
	 * 获取车辆uuid
	 *
	 * @return warn_bus_uuid - 车辆uuid
	 */
	public String getWarnBusUuid() {
		return warnBusUuid;
	}

	/**
	 * 设置车辆uuid
	 *
	 * @param warnBusUuid
	 *            车辆uuid
	 */
	public void setWarnBusUuid(String warnBusUuid) {
		this.warnBusUuid = warnBusUuid == null ? null : warnBusUuid.trim();
	}

	/**
	 * 获取设备uuid
	 *
	 * @return warn_dev_uuid - 设备uuid
	 */
	public String getWarnDevUuid() {
		return warnDevUuid;
	}

	/**
	 * 设置设备uuid
	 *
	 * @param warnDevUuid
	 *            设备uuid
	 */
	public void setWarnDevUuid(String warnDevUuid) {
		this.warnDevUuid = warnDevUuid == null ? null : warnDevUuid.trim();
	}

	/**
	 * 获取报警开始时间
	 *
	 * @return warn_start_time - 报警开始时间
	 */
	public String getWarnStartTime() {
		return warnStartTime;
	}

	/**
	 * 设置报警开始时间
	 *
	 * @param warnStartTime
	 *            报警开始时间
	 */
	public void setWarnStartTime(String warnStartTime) {
		this.warnStartTime = warnStartTime == null ? null : warnStartTime.trim();
	}

	/**
	 * 获取报警结束时间
	 *
	 * @return warn_end_time - 报警结束时间
	 */
	public String getWarnEndTime() {
		return warnEndTime;
	}

	/**
	 * 设置报警结束时间
	 *
	 * @param warnEndTime
	 *            报警结束时间
	 */
	public void setWarnEndTime(String warnEndTime) {
		this.warnEndTime = warnEndTime == null ? null : warnEndTime.trim();
	}

	/**
	 * 获取报警类型 3：故障，4：事故，6：报警，7：偏线，8：超速，9停车，10回场 延安调度系统处理（超速、偏线、报警、停车、回场）5种报警
	 *
	 * @return warn_type - 报警类型 3：故障，4：事故，6：报警，7：偏线，8：超速，9停车，10回场
	 *         延安调度系统处理（超速、偏线、报警、停车、回场）5种报警
	 */
	public String getWarnType() {
		return warnType;
	}

	/**
	 * 设置报警类型 3：故障，4：事故，6：报警，7：偏线，8：超速，9停车，10回场 延安调度系统处理（超速、偏线、报警、停车、回场）5种报警
	 *
	 * @param warnType
	 *            报警类型 3：故障，4：事故，6：报警，7：偏线，8：超速，9停车，10回场
	 *            延安调度系统处理（超速、偏线、报警、停车、回场）5种报警
	 */
	public void setWarnType(String warnType) {
		this.warnType = warnType == null ? null : warnType.trim();
	}

	/**
	 * 获取超速时的速度
	 *
	 * @return warn_speed - 超速时的速度
	 */
	public String getWarnSpeed() {
		return warnSpeed;
	}

	/**
	 * 设置超速时的速度
	 *
	 * @param warnSpeed
	 *            超速时的速度
	 */
	public void setWarnSpeed(String warnSpeed) {
		this.warnSpeed = warnSpeed == null ? null : warnSpeed.trim();
	}

	/**
	 * 获取报警里程(单位：米)
	 *
	 * @return warn_miles - 报警里程(单位：米)
	 */
	public String getWarnMiles() {
		return warnMiles;
	}

	/**
	 * 设置报警里程(单位：米)
	 *
	 * @param warnMiles
	 *            报警里程(单位：米)
	 */
	public void setWarnMiles(String warnMiles) {
		this.warnMiles = warnMiles == null ? null : warnMiles.trim();
	}

	/**
	 * 获取报警时长（秒）
	 *
	 * @return warn_duration - 报警时长（秒）
	 */
	public String getWarnDuration() {
		return warnDuration;
	}

	/**
	 * 设置报警时长（秒）
	 *
	 * @param warnDuration
	 *            报警时长（秒）
	 */
	public void setWarnDuration(String warnDuration) {
		this.warnDuration = warnDuration == null ? null : warnDuration.trim();
	}

	/**
	 * 获取报警起始位置经度
	 *
	 * @return warn_start_lng - 报警起始位置经度
	 */
	public String getWarnStartLng() {
		return warnStartLng;
	}

	/**
	 * 设置报警起始位置经度
	 *
	 * @param warnStartLng
	 *            报警起始位置经度
	 */
	public void setWarnStartLng(String warnStartLng) {
		this.warnStartLng = warnStartLng == null ? null : warnStartLng.trim();
	}

	/**
	 * 获取报警始起位置纬度
	 *
	 * @return warn_start_lat - 报警始起位置纬度
	 */
	public String getWarnStartLat() {
		return warnStartLat;
	}

	/**
	 * 设置报警始起位置纬度
	 *
	 * @param warnStartLat
	 *            报警始起位置纬度
	 */
	public void setWarnStartLat(String warnStartLat) {
		this.warnStartLat = warnStartLat == null ? null : warnStartLat.trim();
	}

	/**
	 * 获取报警结束位置经度
	 *
	 * @return warn_end_lng - 报警结束位置经度
	 */
	public String getWarnEndLng() {
		return warnEndLng;
	}

	/**
	 * 设置报警结束位置经度
	 *
	 * @param warnEndLng
	 *            报警结束位置经度
	 */
	public void setWarnEndLng(String warnEndLng) {
		this.warnEndLng = warnEndLng == null ? null : warnEndLng.trim();
	}

	/**
	 * 获取报警结束位置纬度
	 *
	 * @return warn_end_lat - 报警结束位置纬度
	 */
	public String getWarnEndLat() {
		return warnEndLat;
	}

	/**
	 * 设置报警结束位置纬度
	 *
	 * @param warnEndLat
	 *            报警结束位置纬度
	 */
	public void setWarnEndLat(String warnEndLat) {
		this.warnEndLat = warnEndLat == null ? null : warnEndLat.trim();
	}

	/**
	 * 获取入库时间
	 *
	 * @return warn_storage_time - 入库时间
	 */
	public String getWarnStorageTime() {
		return warnStorageTime;
	}

	/**
	 * 设置入库时间
	 *
	 * @param warnStorageTime
	 *            入库时间
	 */
	public void setWarnStorageTime(String warnStorageTime) {
		this.warnStorageTime = warnStorageTime == null ? null : warnStorageTime.trim();
	}

	/**
	 * 获取更新时间
	 *
	 * @return warn_update_time - 更新时间
	 */
	public String getWarnUpdateTime() {
		return warnUpdateTime;
	}

	/**
	 * 设置更新时间
	 *
	 * @param warnUpdateTime
	 *            更新时间
	 */
	public void setWarnUpdateTime(String warnUpdateTime) {
		this.warnUpdateTime = warnUpdateTime == null ? null : warnUpdateTime.trim();
	}

	/**
	 * 获取删除标记 1：启用 0：禁用
	 *
	 * @return warn_isvalid - 删除标记 1：启用 0：禁用
	 */
	public String getWarnIsvalid() {
		return warnIsvalid;
	}

	/**
	 * 设置删除标记 1：启用 0：禁用
	 *
	 * @param warnIsvalid
	 *            删除标记 1：启用 0：禁用
	 */
	public void setWarnIsvalid(String warnIsvalid) {
		this.warnIsvalid = warnIsvalid == null ? null : warnIsvalid.trim();
	}

	/**
	 * 获取报警关闭标识（0-未关闭，1-被手动关闭）
	 *
	 * @return warn_closed_flag - 报警关闭标识（0-未关闭，1-被手动关闭）
	 */
	public String getWarnClosedFlag() {
		return warnClosedFlag;
	}

	/**
	 * 设置报警关闭标识（0-未关闭，1-被手动关闭）
	 *
	 * @param warnClosedFlag
	 *            报警关闭标识（0-未关闭，1-被手动关闭）
	 */
	public void setWarnClosedFlag(String warnClosedFlag) {
		this.warnClosedFlag = warnClosedFlag == null ? null : warnClosedFlag.trim();
	}

	/**
	 * 获取关闭报警调度员ID
	 *
	 * @return warn_closed_by - 关闭报警调度员ID
	 */
	public String getWarnClosedBy() {
		return warnClosedBy;
	}

	/**
	 * 设置关闭报警调度员ID
	 *
	 * @param warnClosedBy
	 *            关闭报警调度员ID
	 */
	public void setWarnClosedBy(String warnClosedBy) {
		this.warnClosedBy = warnClosedBy == null ? null : warnClosedBy.trim();
	}

	/**
	 * 获取报警关闭时间
	 *
	 * @return warn_closed_time - 报警关闭时间
	 */
	public Date getWarnClosedTime() {
		return warnClosedTime;
	}

	/**
	 * 设置报警关闭时间
	 *
	 * @param warnClosedTime
	 *            报警关闭时间
	 */
	public void setWarnClosedTime(Date warnClosedTime) {
		this.warnClosedTime = warnClosedTime;
	}

	/**
	 * 获取报警关闭说明
	 *
	 * @return warn_closed_note - 报警关闭说明
	 */
	public String getWarnClosedNote() {
		return warnClosedNote;
	}

	/**
	 * 设置报警关闭说明
	 *
	 * @param warnClosedNote
	 *            报警关闭说明
	 */
	public void setWarnClosedNote(String warnClosedNote) {
		this.warnClosedNote = warnClosedNote == null ? null : warnClosedNote.trim();
	}

	/**
	 * 获取运营状态判定，0：非运营，1：运营。该字段由调度员判定，确定报警期间的里程计入运营里程还是非运营里程。
	 *
	 * @return warn_oper_status -
	 *         运营状态判定，0：非运营，1：运营。该字段由调度员判定，确定报警期间的里程计入运营里程还是非运营里程。
	 */
	public String getWarnOperStatus() {
		return warnOperStatus;
	}

	/**
	 * 设置运营状态判定，0：非运营，1：运营。该字段由调度员判定，确定报警期间的里程计入运营里程还是非运营里程。
	 *
	 * @param warnOperStatus
	 *            运营状态判定，0：非运营，1：运营。该字段由调度员判定，确定报警期间的里程计入运营里程还是非运营里程。
	 */
	public void setWarnOperStatus(String warnOperStatus) {
		this.warnOperStatus = warnOperStatus == null ? null : warnOperStatus.trim();
	}

	/**
	 * 获取报警相关的其它业务表格UUID。根据报警的类型有关，偏线报警时，该字段指向t_bus_position_section
	 *
	 * @return warn_ref_uuid -
	 *         报警相关的其它业务表格UUID。根据报警的类型有关，偏线报警时，该字段指向t_bus_position_section
	 */
	public String getWarnRefUuid() {
		return warnRefUuid;
	}

	/**
	 * 设置报警相关的其它业务表格UUID。根据报警的类型有关，偏线报警时，该字段指向t_bus_position_section
	 *
	 * @param warnRefUuid
	 *            报警相关的其它业务表格UUID。根据报警的类型有关，偏线报警时，该字段指向t_bus_position_section
	 */
	public void setWarnRefUuid(String warnRefUuid) {
		this.warnRefUuid = warnRefUuid == null ? null : warnRefUuid.trim();
	}

	/**
	 * 获取报警开始时的里程表数据值
	 *
	 * @return warn_start_odometer - 报警开始时的里程表数据值
	 */
	public Double getWarnStartOdometer() {
		return warnStartOdometer;
	}

	/**
	 * 设置报警开始时的里程表数据值
	 *
	 * @param warnStartOdometer
	 *            报警开始时的里程表数据值
	 */
	public void setWarnStartOdometer(Double warnStartOdometer) {
		this.warnStartOdometer = warnStartOdometer;
	}

	/**
	 * 获取报警结束时的里程表数值
	 *
	 * @return warn_end_odometer - 报警结束时的里程表数值
	 */
	public Double getWarnEndOdometer() {
		return warnEndOdometer;
	}

	/**
	 * 设置报警结束时的里程表数值
	 *
	 * @param warnEndOdometer
	 *            报警结束时的里程表数值
	 */
	public void setWarnEndOdometer(Double warnEndOdometer) {
		this.warnEndOdometer = warnEndOdometer;
	}

	/**
	 * 获取报警站点uuid-如果报警类型为甩站、压站时不为空
	 *
	 * @return warn_sta_uuid - 报警站点uuid-如果报警类型为甩站、压站时不为空
	 */
	public String getWarnStaUuid() {
		return warnStaUuid;
	}

	/**
	 * 设置报警站点uuid-如果报警类型为甩站、压站时不为空
	 *
	 * @param warnStaUuid
	 *            报警站点uuid-如果报警类型为甩站、压站时不为空
	 */
	public void setWarnStaUuid(String warnStaUuid) {
		this.warnStaUuid = warnStaUuid == null ? null : warnStaUuid.trim();
	}

	/**
	 * 获取警告信息是否已读（用于直线图显示）0:未读;1:已读
	 *
	 * @return warn_is_read - 警告信息是否已读（用于直线图显示）0:未读;1:已读
	 */
	public String getWarnIsRead() {
		return warnIsRead;
	}

	/**
	 * 设置警告信息是否已读（用于直线图显示）0:未读;1:已读
	 *
	 * @param warnIsRead
	 *            警告信息是否已读（用于直线图显示）0:未读;1:已读
	 */
	public void setWarnIsRead(String warnIsRead) {
		this.warnIsRead = warnIsRead == null ? null : warnIsRead.trim();
	}

	@Override
	public String toString() {
		StringBuilder sb = new StringBuilder();
		sb.append(getClass().getSimpleName());
		sb.append(" [");
		sb.append("Hash = ").append(hashCode());
		sb.append(", warnUuid=").append(warnUuid);
		sb.append(", warnLineUuid=").append(warnLineUuid);
		sb.append(", warnDrvUuid=").append(warnDrvUuid);
		sb.append(", warnBusUuid=").append(warnBusUuid);
		sb.append(", warnDevUuid=").append(warnDevUuid);
		sb.append(", warnStartTime=").append(warnStartTime);
		sb.append(", warnEndTime=").append(warnEndTime);
		sb.append(", warnType=").append(warnType);
		sb.append(", warnSpeed=").append(warnSpeed);
		sb.append(", warnMiles=").append(warnMiles);
		sb.append(", warnDuration=").append(warnDuration);
		sb.append(", warnStartLng=").append(warnStartLng);
		sb.append(", warnStartLat=").append(warnStartLat);
		sb.append(", warnEndLng=").append(warnEndLng);
		sb.append(", warnEndLat=").append(warnEndLat);
		sb.append(", warnStorageTime=").append(warnStorageTime);
		sb.append(", warnUpdateTime=").append(warnUpdateTime);
		sb.append(", warnIsvalid=").append(warnIsvalid);
		sb.append(", warnClosedFlag=").append(warnClosedFlag);
		sb.append(", warnClosedBy=").append(warnClosedBy);
		sb.append(", warnClosedTime=").append(warnClosedTime);
		sb.append(", warnClosedNote=").append(warnClosedNote);
		sb.append(", warnOperStatus=").append(warnOperStatus);
		sb.append(", warnRefUuid=").append(warnRefUuid);
		sb.append(", warnStartOdometer=").append(warnStartOdometer);
		sb.append(", warnEndOdometer=").append(warnEndOdometer);
		sb.append(", warnStaUuid=").append(warnStaUuid);
		sb.append(", warnIsRead=").append(warnIsRead);
		sb.append("]");
		return sb.toString();
	}
}